package com.leigang.java.code.mulithread.thread;

import java.lang.Thread.State;
import java.util.UUID;

/**
 * @author leig-a
 *
 * 1、Synchronized 内置的Java关键字， Lock 是一个Java类
 * 2、Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁
 * 3、Synchronized 会自动释放锁，lock 必须要手动释放锁!如果不释放锁，死锁
 * 4、Synchronized 线程1(获得锁，阻塞)、线程2( 等待，傻傻的等 ) ; Lock锁就不一定会等待下去;
 * 5、Synchronized 可重入锁，不可以中断的，非公平;Lock，可重入锁，可以判断锁，非公平(可以自己设置);
 * 6、Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码!
 */
public class MyTest {
    public static void main(String[] args) {
//        System.out.println("===========CPU核心数=================");
//        int i = Runtime.getRuntime().availableProcessors();
//        System.out.println(i);
//        System.out.println("============所有线程状态==============");
//        State[] values = State.values();
//        for (State value : values) {
//            System.out.println(value);
//        }

//        testSellTicketSynchronized();
        testSellTicketLock();
    }


    public static void testSellTicketLock() {
        imitateMuliThread(30, 100, false);
    }

    /**
     * synchronized 关键字
     */
    public static void testSellTicketSynchronized() {
        imitateMuliThread(30, 100, true);
    }


    private static void imitateMuliThread(int countThread, int countUser, boolean flag) {
        SellTicketSynchronized sellTicketSynchronized = new SellTicketSynchronized();
        SellTicketLock sellTicketLock = new SellTicketLock();
        for (int i = 0; i < countThread; i++) {
            new Thread(() -> {
                for (int j = 0; j < countUser; j++) {
                    if (flag) {
                        sellTicketSynchronized.sell();
                    } else {
                        sellTicketLock.sell();
                    }
                }
            }, UUID.randomUUID().toString().substring(0, 10)).start();
        }
    }
}
